//
// Created by hjie on 23-5-15.
//

#include "redis_message_reply.h"
#include "redis_message.h"
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>

RedisMessageReply::RedisMessageReply()
{
    m_message = nullptr;
}

RedisMessageReply::~RedisMessageReply()
{
    
}

EmRedisParseStatus RedisMessageReply::ParseData(const std::string &msg)
{

    return EmParseStatusNone;
}

EmRedisParseStatus RedisMessageReply::ParseData(const uint8_t * data, int length, int & use_size)
{

    EmRedisParseStatus status;
    m_message = RedisMessage::ParseRedisMessage(data, length, use_size, status);
    return status;
}

std::vector<RedisMessageReply> RedisMessageReply::Array() 
{
    std::vector<RedisMessageReply> msg_vec;

    RedisMessageArray * array = (RedisMessageArray*)m_message;

    auto & data_array = array->GetMessageVector();

    for (auto & data : data_array)
    {
        RedisMessageReply reply;
        reply.m_message = data;

        msg_vec.push_back(reply);
    }
    return msg_vec;
}

int64_t RedisMessageReply::Number() 
{
    return ((RedisMessageNumber*)m_message)->Number();
}

std::string RedisMessageReply::String()
{
    if (m_message->GetMessageType() == EmStringType)
    {
        return ((RedisMessageString*)m_message)->Show();
    }
    else if (m_message->GetMessageType() == EmLengthStringType)
    {
        return ((RedisMessageLengthString*)m_message)->Show();
    }
    else 
    {
        return "";
    }
}

std::string RedisMessageReply::Error()
{
    return ((RedisMessageError*)m_message)->Error();
}

RedisMessageType RedisMessageReply::GetMsgType()
{
    return m_message->GetMessageType();
}


bool RedisMessageReply::IsNumber()
{
    if (m_message == nullptr)
    {
        return false;
    }
    return m_message->GetMessageType() == EmNumberType ? true : false;
}

bool RedisMessageReply::IsString()
{
    if (m_message == nullptr)
    {
        return false;
    }
    RedisMessageType type = m_message->GetMessageType();
    return (type == EmStringType || type == EmLengthStringType);
}

bool RedisMessageReply::IsArray()
{
    if (m_message == nullptr)
    {
        return false;
    }
    return m_message->GetMessageType() == EmArrayStringType;
}

bool RedisMessageReply::IsError()
{
    if (m_message == nullptr)
    {
        return false;
    }
    return m_message->GetMessageType() == EmErrorType;
}


RedisMessageResponse::RedisMessageResponse()
{
    m_timeout_ms = 1000;
    m_is_async   = 0;
    m_index      = 0;
    m_reply      = NULL;
}

RedisMessageResponse::~RedisMessageResponse()
{
    if (m_reply)
    {
        delete m_reply;
        m_reply = nullptr;
    }
}
